/**
 * Obstacle - 障碍物基类
 * 所有障碍物类型的基础类，提供通用的障碍物行为和属性
 */

import { Entity, EntityType, EntityOptions } from './Entity'

/**
 * 障碍物类型枚举
 */
export enum ObstacleType {
  BARRIER = 'barrier',      // 栅栏 - 静态障碍物
  PIT = 'pit',             // 坑洞 - 需要跳跃避开
  MOVING = 'moving'        // 移动障碍 - 动态移动的障碍物
}

/**
 * 障碍物行为接口
 */
export interface ObstacleBehavior {
  /**
   * 更新障碍物行为
   * @param obstacle - 障碍物实例
   * @param deltaTime - 时间差
   */
  update(obstacle: Obstacle, deltaTime: number): void

  /**
   * 重置行为状态
   */
  reset?(): void
}

/**
 * 障碍物配置选项
 */
export interface ObstacleOptions extends Omit<EntityOptions, 'type'> {
  obstacleType: ObstacleType
  damage?: number
  behavior?: ObstacleBehavior
  canBeDestroyed?: boolean
  scoreValue?: number
}

/**
 * 障碍物基类
 * @class
 */
export abstract class Obstacle extends Entity {
  public readonly obstacleType: ObstacleType
  public damage: number
  public behavior: ObstacleBehavior | null
  public canBeDestroyed: boolean
  public scoreValue: number
  protected isColliding: boolean = false

  /**
   * 创建障碍物实例
   * @param options - 障碍物配置选项
   */
  constructor(options: ObstacleOptions) {
    super({
      ...options,
      type: EntityType.OBSTACLE
    })

    this.obstacleType = options.obstacleType
    this.damage = options.damage || 1
    this.behavior = options.behavior || null
    this.canBeDestroyed = options.canBeDestroyed || false
    this.scoreValue = options.scoreValue || 0
  }

  /**
   * 更新障碍物逻辑
   * @param deltaTime - 距离上一帧的时间差（毫秒）
   */
  update(deltaTime: number): void {
    if (!this.active) return

    // 应用基础物理更新
    this.applyPhysics(deltaTime)

    // 执行特定行为
    if (this.behavior) {
      this.behavior.update(this, deltaTime)
    }

    // 执行子类特定的更新逻辑
    this.updateObstacle(deltaTime)

    // 检查是否需要移除（超出屏幕边界）
    this.checkBounds()
  }

  /**
   * 子类实现的具体更新逻辑
   * @param deltaTime - 时间差
   */
  protected abstract updateObstacle(deltaTime: number): void

  /**
   * 处理与玩家的碰撞
   * @param player - 玩家实体
   * @returns 是否发生了碰撞
   */
  onCollision(player: Entity): boolean {
    if (this.isColliding) return false

    this.isColliding = true
    
    // 执行碰撞逻辑
    const collisionHandled = this.handleCollision(player)
    
    // 如果障碍物可以被摧毁，则标记为非活跃状态
    if (this.canBeDestroyed && collisionHandled) {
      this.destroy()
    }

    return collisionHandled
  }

  /**
   * 处理碰撞的具体逻辑（子类可重写）
   * @param player - 玩家实体
   * @returns 是否成功处理了碰撞
   */
  protected handleCollision(_player: Entity): boolean {
    // 默认碰撞处理：造成伤害
    console.log(`玩家与${this.obstacleType}障碍物碰撞，造成${this.damage}点伤害`)
    return true
  }

  /**
   * 重置碰撞状态
   */
  resetCollision(): void {
    this.isColliding = false
  }

  /**
   * 检查边界并处理超出屏幕的情况
   */
  protected checkBounds(): void {
    // 如果障碍物完全移出左侧屏幕，标记为需要移除
    if (this.x + this.width < -100) {
      this.destroy()
    }
  }

  /**
   * 获取障碍物的威胁等级
   * @returns 威胁等级 (1-5)
   */
  getThreatLevel(): number {
    let level = 1
    
    // 根据伤害值调整威胁等级
    level += Math.min(this.damage - 1, 2)
    
    // 移动障碍物威胁等级更高
    if (this.obstacleType === ObstacleType.MOVING) {
      level += 1
    }
    
    return Math.min(level, 5)
  }

  /**
   * 获取障碍物描述信息
   * @returns 障碍物描述
   */
  getDescription(): string {
    return `${this.obstacleType}障碍物 - 伤害: ${this.damage}, 威胁等级: ${this.getThreatLevel()}`
  }

  /**
   * 销毁障碍物时的清理工作
   */
  destroy(): void {
    // 重置行为状态
    if (this.behavior && this.behavior.reset) {
      this.behavior.reset()
    }
    
    super.destroy()
  }

  /**
   * 获取默认颜色（根据障碍物类型）
   */
  protected getDefaultColor(): string {
    switch (this.obstacleType) {
      case ObstacleType.BARRIER:
        return '#8B4513' // 棕色 - 栅栏
      case ObstacleType.PIT:
        return '#2F2F2F' // 深灰色 - 坑洞
      case ObstacleType.MOVING:
        return '#FF4444' // 红色 - 移动障碍
      default:
        return '#F44336' // 默认红色
    }
  }
}